/*
 * ./src/fonction_algo.h
 * Copyright (C) 2009 lameire alexis
 * 
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef FONCTION_ALGO_H
#define FONCTION_ALGO_H
#include <regex.h>
#include <libintl.h>
#include <locale.h>
#include <stdio.h>
#include "couleurs.h"
#include "struct.h"
#define _(STRING)            gettext(STRING)

char *tirer_un_mot(char *categorie);
/**
 * \brief tirer_un_mot : permet de tirer un mot au hazard dans la bdd
 * \param categorie cathégorie dans laquel le mot est tirer
 * \return renvois un pointeur sur le mot alouer : ne pas oublier de le libérer une fois l'utilisation terminer
 */
int compter(FILE * fichier, char token);
/**
 * \brief compter : compte le nombre de carractére depuis la position courrente jusqu'a la premiére  occurence de token
 * \param fichier un pointeur sur le fichier ouvert
 * \param token	l'élément stopent le comptage
 * \return renvois un int : le nombre de carractére jusqu'au token
 */
char *recuperer(FILE * fichier, int taille);
/**
 * \brief recuprer : aloue une chaine a la taille des données et les récupérent dans un fichier
 * \param fichier le fichier dans lequel récupérer les données
 * \param taille la taille des données a récupérer
 * \return renvois un char* : la chaine alouée qu'il faura libérer
 * \return renvois NULL en cas de taille incorrecte
 * \return en cas d'allocation impossible le programme est quiter
 */
config *ouvrir_fichier_de_conf();
/**
 * \brief ouvrir_fichier_de_conf : ouvre le fichier de configuration et récupére les information contenu en faisent les teste néssésaires
 * \param aucun
 * \return renvois un pointeur sur config* contenant tout les élément du fichier de configuration
 * \return en cas d'érreur fatal dans la fonction le programme est fermer
 */
int parse_regex(const char *regex, const char *phrase);
/**
 * \brief parse_regex : évalue une expression réguliére
 * \param regex	l'expression réguliére a exécuter
 * \param phrase la chaine qui doit étre tester
 * \return renvois 1 en cas de succés
 * \return renvois 0 en cas d'échec
 * \return en cas d'érreur le programme est ferm
 */
void parse_regex_error(int erreur, regex_t * regex_compiler);
/**
 * \brief parse_regex_error : renvois l'erreur reporter lors de l'évaluation de la régex a l'utilisateur et ferme le programme
 * \param erreur code d'erreur renvoyer
 * \param regex_compiler la structure de régex qui a produit l'erreur
 * \return aucune
 * \return se contante de fermer le programme et en postant l'erreur plus ou moins détailler selon la mémoire disponible
 */
void couper_espace(char *ligne);
/**
 * \brief couper_espace : supprimer les espace en fin de chaine
 * \param ligne	ligne a traiter
 * \return aucune
 */
void copier_fichier(char *src, char *dest);
/**
 * \brief copier_fichier : copie le fichier source dans le fichier destinataire
 * \param src nom du fichier a copier
 * \param dest nom du fichier de destination
 * \return aucune
 * \return fermeture du programme en cas d'erreur d'ouverture
 */
void suprimer_ligne(char *src, int curseur_debut);
/**
 * \brief suprimer_ligne : supprime une ligne dans un fichier
 * \param src nom du fichier source
 * \param curseur_debut	position renvoyer par ftell au début de la ligne a supprimer
 * \return aucune
 * \return modifie le fichier source
 * \return en cas d'érreur le programme est quiter
 */
int verifier_mot(FILE * fichier, char *mot);
/**
 * \brief verifier_mot : vérifie l'existance du mot dans un fichier de dictionnaire
 * \param fichier pointeur sur le fichier dictionaire
 * \param mot mot a vérifier dans le fichier
 * \return renvois la position du debut du mot si trouver
 * \return renvois -1 en cas d'échec
 */
char *sha1sun(char *key);
/**
 * \brief sha1sun : calcul la somme de controle sha1
 * \param key expression a traiter
 * \return renvois un char : la some de controle sha1 coder en exadécimal codé sur 20 bit
 */
int recuperer_args_ajouter(const char *src, char **categorie, char **mot);
/**
 * \brief recuperer_args_ajouter : separe les différent argument pour la fonction cmd_ajouter et cmd_retirer
 * \param src chaine source a divider
 * \param cathegorie un pointeur vers le pointeur recevent la chaine de la categorie du mot
 * \param mot un pointeur vers le pointeur recevent le mot a traitrer
 * \return renvois 1 en cas de chaine d'entrée invalide
 * \return renvois 0 en cas de succés
 * \return ferme le programme en cas d'erreur d'allocation
 */
int compter_colonnes(void *nb_appel, int argc, char **argv, char **nom_colones);
/**
 * \brief compter_colones : compte le nombre de fois ou on appel la fonction
 * \param nb_appel variable stockent le nombre d'apel
 * \param argc nombre de colones de la requettes (non utiliser)
 * \param argv arguments des colones
 * \param nom_colones nom des différentes colones
 * \return 0
 */
void ajouter_score(char *pseudo, int score);
/**
 * \brief ajouter_score : ajoute le score obtenu a la derniére pardie dans la bdd
 * \param pseudo pseudo du jouer a incrémenter
 * \param score	score a rajouter
 * \return aucun
 */
void hl_users(irc_session_t * session, char *chan);
/**
 * \brief hl_users : hl les différents users
 * \param session session renvoyer par ircclient
 * \param chan chan des gens a hler
 * \return aucune
 */
#endif
